// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/files/file_enumerator.h"

#include <dirent.h>
#include <errno.h>
#include <fnmatch.h>
#include <stdint.h>

#include "base/logging.h"
#include "base/threading/thread_restrictions.h"
#include "build/build_config.h"

namespace base {

// FileEnumerator::FileInfo ----------------------------------------------------

FileEnumerator::FileInfo::FileInfo()
{
    memset(&stat_, 0, sizeof(stat_));
}

bool FileEnumerator::FileInfo::IsDirectory() const
{
    return S_ISDIR(stat_.st_mode);
}

FilePath FileEnumerator::FileInfo::GetName() const
{
    return filename_;
}

int64_t FileEnumerator::FileInfo::GetSize() const
{
    return stat_.st_size;
}

base::Time FileEnumerator::FileInfo::GetLastModifiedTime() const
{
    return base::Time::FromTimeT(stat_.st_mtime);
}

// FileEnumerator --------------------------------------------------------------

FileEnumerator::FileEnumerator(const FilePath& root_path,
    bool recursive,
    int file_type)
    : current_directory_entry_(0)
    , root_path_(root_path)
    , recursive_(recursive)
    , file_type_(file_type)
{
    // INCLUDE_DOT_DOT must not be specified if recursive.
    DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_)));
    pending_paths_.push(root_path);
}

FileEnumerator::FileEnumerator(const FilePath& root_path,
    bool recursive,
    int file_type,
    const FilePath::StringType& pattern)
    : current_directory_entry_(0)
    , root_path_(root_path)
    , recursive_(recursive)
    , file_type_(file_type)
    , pattern_(root_path.Append(pattern).value())
{
    // INCLUDE_DOT_DOT must not be specified if recursive.
    DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_)));
    // The Windows version of this code appends the pattern to the root_path,
    // potentially only matching against items in the top-most directory.
    // Do the same here.
    if (pattern.empty())
        pattern_ = FilePath::StringType();
    pending_paths_.push(root_path);
}

FileEnumerator::~FileEnumerator()
{
}

FilePath FileEnumerator::Next()
{
    ++current_directory_entry_;

    // While we've exhausted the entries in the current directory, do the next
    while (current_directory_entry_ >= directory_entries_.size()) {
        if (pending_paths_.empty())
            return FilePath();

        root_path_ = pending_paths_.top();
        root_path_ = root_path_.StripTrailingSeparators();
        pending_paths_.pop();

        std::vector<FileInfo> entries;
        if (!ReadDirectory(&entries, root_path_, file_type_ & SHOW_SYM_LINKS))
            continue;

        directory_entries_.clear();
        current_directory_entry_ = 0;
        for (std::vector<FileInfo>::const_iterator i = entries.begin();
             i != entries.end(); ++i) {
            FilePath full_path = root_path_.Append(i->filename_);
            if (ShouldSkip(full_path))
                continue;

            if (pattern_.size() && fnmatch(pattern_.c_str(), full_path.value().c_str(), FNM_NOESCAPE))
                continue;

            if (recursive_ && S_ISDIR(i->stat_.st_mode))
                pending_paths_.push(full_path);

            if ((S_ISDIR(i->stat_.st_mode) && (file_type_ & DIRECTORIES)) || (!S_ISDIR(i->stat_.st_mode) && (file_type_ & FILES)))
                directory_entries_.push_back(*i);
        }
    }

    return root_path_.Append(
        directory_entries_[current_directory_entry_].filename_);
}

FileEnumerator::FileInfo FileEnumerator::GetInfo() const
{
    return directory_entries_[current_directory_entry_];
}

bool FileEnumerator::ReadDirectory(std::vector<FileInfo>* entries,
    const FilePath& source, bool show_links)
{
    base::ThreadRestrictions::AssertIOAllowed();
    DIR* dir = opendir(source.value().c_str());
    if (!dir)
        return false;

#if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_BSD) && !defined(OS_SOLARIS) && !defined(OS_ANDROID)
#error Port warning: depending on the definition of struct dirent, \
         additional space for pathname may be needed
#endif

    struct dirent dent_buf;
    struct dirent* dent;
    while (readdir_r(dir, &dent_buf, &dent) == 0 && dent) {
        FileInfo info;
        info.filename_ = FilePath(dent->d_name);

        FilePath full_name = source.Append(dent->d_name);
        int ret;
        if (show_links)
            ret = lstat(full_name.value().c_str(), &info.stat_);
        else
            ret = stat(full_name.value().c_str(), &info.stat_);
        if (ret < 0) {
            // Print the stat() error message unless it was ENOENT and we're
            // following symlinks.
            if (!(errno == ENOENT && !show_links)) {
                DPLOG(ERROR) << "Couldn't stat "
                             << source.Append(dent->d_name).value();
            }
            memset(&info.stat_, 0, sizeof(info.stat_));
        }
        entries->push_back(info);
    }

    closedir(dir);
    return true;
}

} // namespace base
